package lyl.hash;

import java.util.*;

/**
 * 定义一个单词的“兄弟单词”为：交换该单词字母顺序（注：可以交换任意次），而不添加、删除、修改原有的字母就能生成的单词。
 * 兄弟单词要求和原来的单词不同。例如： ab 和 ba 是兄弟单词。 ab 和 ab 则不是兄弟单词。
 * 现在给定你 n 个单词，另外再给你一个单词 x ，让你寻找 x 的兄弟单词里，按字典序排列后的第 k 个单词是什么？
 * 注意：字典中可能有重复单词。
 *
 * 数据范围：1 \le n \le 1000 \1≤n≤1000 ，输入的字符串长度满足 1 \le len(str) \le 10 \1≤len(str)≤10  ， 1 \le k < n \1≤k<n
 * 输入描述：
 * 输入只有一行。 先输入字典中单词的个数n，再输入n个单词作为字典单词。 然后输入一个单词x 最后后输入一个整数k
 * 输出描述：
 * 第一行输出查找到x的兄弟单词的个数m 第二行输出查找到的按照字典顺序排序后的第k个兄弟单词，没有符合第k个的话则不用输出。
 */
public class Brother {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String s = sc.nextLine();
        String[] strings = s.split(" ");
        int num = Integer.parseInt(strings[0]);
        String[] brothers = new String[num];
        for (int i = 1,j = 0; i <= num; i++,j++) {
            brothers[j] = strings[i];
        }
        String compare = strings[strings.length - 2];
        int k = Integer.parseInt(strings[strings.length - 1]);
        findBrother(num,brothers,compare,k);

    }
    public static void findBrother(int num,String[] brothers,String compare,int k){
        Map<Character,Integer> map = new HashMap<>();
        for(char c : compare.toCharArray()){
            if(map.containsKey(c)){
                map.put(c,map.get(c) + 1);
            }else {
                map.put(c,1);
            }
        }
        int total = 0;
        List<String> list = new ArrayList<>();
        for (String brother : brothers) {
            if(brother.length() != compare.length()){
                continue;
            }
            if(!brother.equals(compare)) {
                Map<Character, Integer> mapCompare = new HashMap<>();
                for (Character ch : brother.toCharArray()) {
                    if (mapCompare.containsKey(ch)) {
                        mapCompare.put(ch, mapCompare.get(ch) + 1);
                    } else {
                        mapCompare.put(ch, 1);
                    }
                }

                Set<Character> keSet = map.keySet();
                boolean flag = false;

                for (Character character : keSet) {
                    if (!mapCompare.containsKey(character)){
                        flag = false;
                        break;
                    } else if (!Objects.equals(mapCompare.get(character), map.get(character))) {
                        flag = false;
                        break;
                    }else {
                       flag = true;
                    }
                }
                if (flag){
                    total++;
                    list.add(brother);
                }
            }
        }
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return myCompare(o1,o2);
            }
        });
        System.out.println(total);
        if(total!=0){
            System.out.println(list.get(k-1));
        }

    }

    public static int myCompare(String o1, String o2){
        char[] array1 = o1.toCharArray();
        char[] array2 = o2.toCharArray();
        for (int i = 0; i < o1.length(); i++) {
            if(array1[i] - array2[i] != 0){

                return array1[i] - array2[i];
            }

        }
        return 0;
    }
}
